home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / site-packages / impacket / dcerpc / svcctl.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-06-30  |  22.8 KB  |  660 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import array
  5. from struct import *
  6. from impacket import ImpactPacket
  7. import dcerpc
  8. MSRPC_UUID_SVCCTL = '\x81\xbbz6D\x98\xf15\xad2\x98\xf08\x00\x10\x03\x02\x00\x00\x00'
  9.  
  10. class SVCCTLOpenSCManagerHeader(ImpactPacket.Header):
  11.     OP_NUM = 27
  12.     __SIZE = 32
  13.     
  14.     def __init__(self, aBuffer = None):
  15.         ImpactPacket.Header.__init__(self, SVCCTLOpenSCManagerHeader._SVCCTLOpenSCManagerHeader__SIZE)
  16.         self.set_referent_id(16777215)
  17.         self.set_access_mask(983103)
  18.         if aBuffer:
  19.             self.load_header(aBuffer)
  20.         
  21.  
  22.     
  23.     def get_referent_id(self):
  24.         return self.get_long(0, '<')
  25.  
  26.     
  27.     def set_referent_id(self, id):
  28.         self.set_long(0, id, '<')
  29.  
  30.     
  31.     def get_max_count(self):
  32.         return self.get_long(4, '<')
  33.  
  34.     
  35.     def set_max_count(self, num):
  36.         self.set_long(4, num, '<')
  37.  
  38.     
  39.     def get_offset(self):
  40.         return self.get_long(8, '<')
  41.  
  42.     
  43.     def set_offset(self, num):
  44.         self.set_long(8, num, '<')
  45.  
  46.     
  47.     def get_cur_count(self):
  48.         return self.get_long(12, '<')
  49.  
  50.     
  51.     def set_cur_count(self, num):
  52.         self.set_long(12, num, '<')
  53.  
  54.     
  55.     def get_machine_name(self):
  56.         return self.get_bytes().tostring()[:20]
  57.  
  58.     
  59.     def set_machine_name(self, name):
  60.         if not len(name) <= 8:
  61.             raise AssertionError
  62.         self.set_max_count(len(name) + 1)
  63.         self.set_cur_count(len(name) + 1)
  64.         self.get_bytes()[16:24] = array.array('B', name + (8 - len(name)) * '\x00')
  65.  
  66.     
  67.     def get_access_mask(self):
  68.         return self.get_long(28, '<')
  69.  
  70.     
  71.     def set_access_mask(self, mask):
  72.         self.set_long(28, mask, '<')
  73.  
  74.     
  75.     def get_header_size(self):
  76.         return SVCCTLOpenSCManagerHeader._SVCCTLOpenSCManagerHeader__SIZE
  77.  
  78.  
  79.  
  80. class SVCCTLRespOpenSCManagerHeader(ImpactPacket.Header):
  81.     __SIZE = 24
  82.     
  83.     def __init__(self, aBuffer = None):
  84.         ImpactPacket.Header.__init__(self, SVCCTLRespOpenSCManagerHeader._SVCCTLRespOpenSCManagerHeader__SIZE)
  85.         if aBuffer:
  86.             self.load_header(aBuffer)
  87.         
  88.  
  89.     
  90.     def get_context_handle(self):
  91.         return self.get_bytes().tolist()[:20]
  92.  
  93.     
  94.     def set_context_handle(self, handle):
  95.         if not 20 == len(handle):
  96.             raise AssertionError
  97.         self.get_bytes()[:20] = array.array('B', handle)
  98.  
  99.     
  100.     def get_return_code(self):
  101.         return self.get_long(20, '<')
  102.  
  103.     
  104.     def set_return_code(self, code):
  105.         self.set_long(20, code, '<')
  106.  
  107.     
  108.     def get_header_size(self):
  109.         return SVCCTLRespOpenSCManagerHeader._SVCCTLRespOpenSCManagerHeader__SIZE
  110.  
  111.  
  112.  
  113. class SVCCTLOpenServiceHeader(ImpactPacket.Header):
  114.     OP_NUM = 28
  115.     __SIZE = 48
  116.     
  117.     def __init__(self, aBuffer = None):
  118.         ImpactPacket.Header.__init__(self, SVCCTLOpenServiceHeader._SVCCTLOpenServiceHeader__SIZE)
  119.         self.set_max_count(9)
  120.         self.set_cur_count(9)
  121.         self.get_bytes()[40:] = array.array('B', '\x00\x10H`\xff\x01\x0f\x00')
  122.         if aBuffer:
  123.             self.load_header(aBuffer)
  124.         
  125.  
  126.     
  127.     def get_context_handle(self):
  128.         return self.get_bytes().tolist()[:20]
  129.  
  130.     
  131.     def set_context_handle(self, handle):
  132.         if not 20 == len(handle):
  133.             raise AssertionError
  134.         self.get_bytes()[:20] = array.array('B', handle)
  135.  
  136.     
  137.     def get_max_count(self):
  138.         return self.get_long(20, '<')
  139.  
  140.     
  141.     def set_max_count(self, num):
  142.         self.set_long(20, num, '<')
  143.  
  144.     
  145.     def get_offset(self):
  146.         return self.get_long(24, '<')
  147.  
  148.     
  149.     def set_offset(self, num):
  150.         self.set_long(24, num, '<')
  151.  
  152.     
  153.     def get_cur_count(self):
  154.         return self.get_long(28, '<')
  155.  
  156.     
  157.     def set_cur_count(self, num):
  158.         self.set_long(28, num, '<')
  159.  
  160.     
  161.     def get_service_name(self):
  162.         return self.get_bytes().tostring()[32:40]
  163.  
  164.     
  165.     def set_service_name(self, name):
  166.         if not len(name) <= 8:
  167.             raise AssertionError
  168.         self.get_bytes()[32:40] = array.array('B', name + (8 - len(name)) * '\x00')
  169.  
  170.     
  171.     def get_header_size(self):
  172.         return SVCCTLOpenServiceHeader._SVCCTLOpenServiceHeader__SIZE
  173.  
  174.  
  175.  
  176. class SVCCTLRespOpenServiceHeader(ImpactPacket.Header):
  177.     __SIZE = 24
  178.     
  179.     def __init__(self, aBuffer = None):
  180.         ImpactPacket.Header.__init__(self, SVCCTLRespOpenServiceHeader._SVCCTLRespOpenServiceHeader__SIZE)
  181.         if aBuffer:
  182.             self.load_header(aBuffer)
  183.         
  184.  
  185.     
  186.     def get_context_handle(self):
  187.         return self.get_bytes().tolist()[:20]
  188.  
  189.     
  190.     def set_context_handle(self, handle):
  191.         if not 20 == len(handle):
  192.             raise AssertionError
  193.         self.get_bytes()[:20] = array.array('B', handle)
  194.  
  195.     
  196.     def get_return_code(self):
  197.         return self.get_long(20, '<')
  198.  
  199.     
  200.     def set_return_code(self, code):
  201.         self.set_long(20, code, '<')
  202.  
  203.     
  204.     def get_header_size(self):
  205.         return SVCCTLRespOpenServiceHeader._SVCCTLRespOpenServiceHeader__SIZE
  206.  
  207.  
  208.  
  209. class SVCCTLCloseServiceHeader(ImpactPacket.Header):
  210.     OP_NUM = 0
  211.     __SIZE = 20
  212.     
  213.     def __init__(self, aBuffer = None):
  214.         ImpactPacket.Header.__init__(self, SVCCTLCloseServiceHeader._SVCCTLCloseServiceHeader__SIZE)
  215.         if aBuffer:
  216.             self.load_header(aBuffer)
  217.         
  218.  
  219.     
  220.     def get_context_handle(self):
  221.         return self.get_bytes().tolist()[:]
  222.  
  223.     
  224.     def set_context_handle(self, handle):
  225.         if not 20 == len(handle):
  226.             raise AssertionError
  227.         self.get_bytes()[:] = array.array('B', handle)
  228.  
  229.     
  230.     def get_header_size(self):
  231.         return SVCCTLCloseServiceHeader._SVCCTLCloseServiceHeader__SIZE
  232.  
  233.  
  234.  
  235. class SVCCTLRespCloseServiceHeader(ImpactPacket.Header):
  236.     __SIZE = 24
  237.     
  238.     def __init__(self, aBuffer = None):
  239.         ImpactPacket.Header.__init__(self, SVCCTLRespCloseServiceHeader._SVCCTLRespCloseServiceHeader__SIZE)
  240.         if aBuffer:
  241.             self.load_header(aBuffer)
  242.         
  243.  
  244.     
  245.     def get_context_handle(self):
  246.         return self.get_bytes().tolist()[:20]
  247.  
  248.     
  249.     def set_context_handle(self, handle):
  250.         if not 20 == len(handle):
  251.             raise AssertionError
  252.         self.get_bytes()[:20] = array.array('B', handle)
  253.  
  254.     
  255.     def get_return_code(self):
  256.         return self.get_long(20, '<')
  257.  
  258.     
  259.     def set_return_code(self, code):
  260.         self.set_long(20, code, '<')
  261.  
  262.     
  263.     def get_header_size(self):
  264.         return SVCCTLRespCloseServiceHeader._SVCCTLRespCloseServiceHeader__SIZE
  265.  
  266.  
  267.  
  268. class SVCCTLCreateServiceHeader(ImpactPacket.Header):
  269.     OP_NUM = 24
  270.     __SIZE = 132
  271.     
  272.     def __init__(self, aBuffer = None):
  273.         ImpactPacket.Header.__init__(self, SVCCTLCreateServiceHeader._SVCCTLCreateServiceHeader__SIZE)
  274.         self.set_name_max_count(9)
  275.         self.set_name_cur_count(9)
  276.         self.set_service_flags(272)
  277.         self.set_start_mode(2)
  278.         self.get_bytes()[40:48] = array.array('B', '\x00\x10H`\xe4\xa3@\x00')
  279.         self.get_bytes()[68:76] = array.array('B', '\x00\x00\x00\x00\xff\x01\x0f\x00')
  280.         self.get_bytes()[84:88] = array.array('B', '\x01\x00\x00\x00')
  281.         if aBuffer:
  282.             self.load_header(aBuffer)
  283.         
  284.  
  285.     
  286.     def get_context_handle(self):
  287.         return self.get_bytes().tolist()[:20]
  288.  
  289.     
  290.     def set_context_handle(self, handle):
  291.         if not 20 == len(handle):
  292.             raise AssertionError
  293.         self.get_bytes()[:20] = array.array('B', handle)
  294.  
  295.     
  296.     def get_name_max_count(self):
  297.         return self.get_long(4, '<')
  298.  
  299.     
  300.     def set_name_max_count(self, num):
  301.         self.set_long(20, num, '<')
  302.         self.set_long(48, num, '<')
  303.  
  304.     
  305.     def get_name_offset(self):
  306.         return self.get_long(8, '<')
  307.  
  308.     
  309.     def set_name_offset(self, num):
  310.         self.set_long(24, num, '<')
  311.         self.set_long(52, num, '<')
  312.  
  313.     
  314.     def get_name_cur_count(self):
  315.         return self.get_long(12, '<')
  316.  
  317.     
  318.     def set_name_cur_count(self, num):
  319.         self.set_long(28, num, '<')
  320.         self.set_long(56, num, '<')
  321.  
  322.     
  323.     def get_service_name(self):
  324.         return self.get_bytes().tostring()[32:40]
  325.  
  326.     
  327.     def set_service_name(self, name):
  328.         self.get_bytes()[32:40] = array.array('B', name + (8 - len(name)) * '\x00')
  329.         self.get_bytes()[60:68] = array.array('B', name + (8 - len(name)) * '\x00')
  330.  
  331.     
  332.     def get_service_flags(self):
  333.         return self.get_long(76, '<')
  334.  
  335.     
  336.     def set_service_flags(self, flags):
  337.         self.set_long(76, flags, '<')
  338.  
  339.     
  340.     def get_start_mode(self):
  341.         return self.get_long(80, '<')
  342.  
  343.     
  344.     def set_start_mode(self, mode):
  345.         self.set_long(80, mode, '<')
  346.  
  347.     
  348.     def get_path_max_count(self):
  349.         return self.get_long(88, '<')
  350.  
  351.     
  352.     def set_path_max_count(self, num):
  353.         self.set_long(88, num, '<')
  354.  
  355.     
  356.     def get_path_offset(self):
  357.         return self.get_long(92, '<')
  358.  
  359.     
  360.     def set_path_offset(self, num):
  361.         self.set_long(92, num, '<')
  362.  
  363.     
  364.     def get_path_cur_count(self):
  365.         return self.get_long(96, '<')
  366.  
  367.     
  368.     def set_path_cur_count(self, num):
  369.         self.set_long(96, num, '<')
  370.  
  371.     
  372.     def get_service_path(self):
  373.         return self.get_bytes().tostring()[100:-32]
  374.  
  375.     
  376.     def set_service_path(self, path):
  377.         self.get_bytes()[100:-32] = array.array('B', path)
  378.         self.set_path_max_count(len(path) + 1)
  379.         self.set_path_cur_count(len(path) + 1)
  380.  
  381.     
  382.     def get_header_size(self):
  383.         var_size = len(self.get_bytes()) - SVCCTLCreateServiceHeader._SVCCTLCreateServiceHeader__SIZE
  384.         if not var_size > 0:
  385.             raise AssertionError
  386.         return SVCCTLCreateServiceHeader._SVCCTLCreateServiceHeader__SIZE + var_size
  387.  
  388.  
  389.  
  390. class SVCCTLRespCreateServiceHeader(ImpactPacket.Header):
  391.     __SIZE = 28
  392.     
  393.     def __init__(self, aBuffer = None):
  394.         ImpactPacket.Header.__init__(self, SVCCTLRespCreateServiceHeader._SVCCTLRespCreateServiceHeader__SIZE)
  395.         if aBuffer:
  396.             self.load_header(aBuffer)
  397.         
  398.  
  399.     
  400.     def get_context_handle(self):
  401.         return self.get_bytes().tolist()[4:24]
  402.  
  403.     
  404.     def set_context_handle(self, handle):
  405.         if not 20 == len(handle):
  406.             raise AssertionError
  407.         self.get_bytes()[4:24] = array.array('B', handle)
  408.  
  409.     
  410.     def get_return_code(self):
  411.         return self.get_long(24, '<')
  412.  
  413.     
  414.     def set_return_code(self, code):
  415.         self.set_long(24, code, '<')
  416.  
  417.     
  418.     def get_header_size(self):
  419.         return SVCCTLRespCreateServiceHeader._SVCCTLRespCreateServiceHeader__SIZE
  420.  
  421.  
  422.  
  423. class SVCCTLDeleteServiceHeader(ImpactPacket.Header):
  424.     OP_NUM = 2
  425.     __SIZE = 20
  426.     
  427.     def __init__(self, aBuffer = None):
  428.         ImpactPacket.Header.__init__(self, SVCCTLDeleteServiceHeader._SVCCTLDeleteServiceHeader__SIZE)
  429.         if aBuffer:
  430.             self.load_header(aBuffer)
  431.         
  432.  
  433.     
  434.     def get_context_handle(self):
  435.         return self.get_bytes().tolist()[:20]
  436.  
  437.     
  438.     def set_context_handle(self, handle):
  439.         if not 20 == len(handle):
  440.             raise AssertionError
  441.         self.get_bytes()[:20] = array.array('B', handle)
  442.  
  443.     
  444.     def get_header_size(self):
  445.         return SVCCTLDeleteServiceHeader._SVCCTLDeleteServiceHeader__SIZE
  446.  
  447.  
  448.  
  449. class SVCCTLRespDeleteServiceHeader(dcerpc.MSRPCHeader):
  450.     __SIZE = 4
  451.     
  452.     def __init__(self, aBuffer = None):
  453.         ImpactPacket.Header.__init__(self, SVCCTLRespDeleteServiceHeader._SVCCTLRespDeleteServiceHeader__SIZE)
  454.         if aBuffer:
  455.             self.load_header(aBuffer)
  456.         
  457.  
  458.     
  459.     def get_return_code(self):
  460.         return self.get_long(0, '<')
  461.  
  462.     
  463.     def set_return_code(self, code):
  464.         self.set_long(0, code, '<')
  465.  
  466.     
  467.     def get_header_size(self):
  468.         return SVCCTLRespDeleteServiceHeader._SVCCTLRespDeleteServiceHeader__SIZE
  469.  
  470.  
  471.  
  472. class SVCCTLStopServiceHeader(ImpactPacket.Header):
  473.     OP_NUM = 1
  474.     __SIZE = 24
  475.     
  476.     def __init__(self, aBuffer = None):
  477.         ImpactPacket.Header.__init__(self, SVCCTLStopServiceHeader._SVCCTLStopServiceHeader__SIZE)
  478.         self.get_bytes()[20:] = array.array('B', '\x01\x00\x00\x00')
  479.         if aBuffer:
  480.             self.load_header(aBuffer)
  481.         
  482.  
  483.     
  484.     def get_context_handle(self):
  485.         return self.get_bytes().tolist()[:20]
  486.  
  487.     
  488.     def set_context_handle(self, handle):
  489.         if not 20 == len(handle):
  490.             raise AssertionError
  491.         self.get_bytes()[:20] = array.array('B', handle)
  492.  
  493.     
  494.     def get_header_size(self):
  495.         return SVCCTLStopServiceHeader._SVCCTLStopServiceHeader__SIZE
  496.  
  497.  
  498.  
  499. class SVCCTLRespStopServiceHeader(ImpactPacket.Header):
  500.     __SIZE = 32
  501.     
  502.     def __init__(self, aBuffer = None):
  503.         ImpactPacket.Header.__init__(self, SVCCTLRespStopServiceHeader._SVCCTLRespStopServiceHeader__SIZE)
  504.         if aBuffer:
  505.             self.load_header(aBuffer)
  506.         
  507.  
  508.     
  509.     def get_return_code(self):
  510.         return self.get_long(28, '<')
  511.  
  512.     
  513.     def set_return_code(self, code):
  514.         self.set_long(28, code, '<')
  515.  
  516.     
  517.     def get_header_size(self):
  518.         return SVCCTLRespStopServiceHeader._SVCCTLRespStopServiceHeader__SIZE
  519.  
  520.  
  521.  
  522. class SVCCTLStartServiceHeader(ImpactPacket.Header):
  523.     OP_NUM = 31
  524.     __SIZE = 32
  525.     
  526.     def __init__(self, aBuffer = None):
  527.         ImpactPacket.Header.__init__(self, SVCCTLStartServiceHeader._SVCCTLStartServiceHeader__SIZE)
  528.         if aBuffer:
  529.             self.load_header(aBuffer)
  530.         
  531.  
  532.     
  533.     def get_context_handle(self):
  534.         return self.get_bytes().tolist()[:20]
  535.  
  536.     
  537.     def set_context_handle(self, handle):
  538.         if not 20 == len(handle):
  539.             raise AssertionError
  540.         self.get_bytes()[:20] = array.array('B', handle)
  541.  
  542.     
  543.     def get_arguments(self):
  544.         raise Exception, 'method not implemented'
  545.  
  546.     
  547.     def set_arguments(self, arguments):
  548.         args_data = apply(pack, [
  549.             '<' + 'L' * len(arguments)] + map(id, arguments))
  550.         args_data += reduce((lambda a, b: a + b), map((lambda element: pack('<LLL', len(element) + 1, 0, len(element) + 1) + element + '\x00' + '\x00' * ((4 - (len(element) + 1) % 4) % 4)), arguments), '')
  551.         data = pack('<LLL', len(arguments), id(arguments), len(arguments)) + args_data
  552.         self.get_bytes()[20:] = array.array('B', data)
  553.  
  554.     
  555.     def get_header_size(self):
  556.         var_size = len(self.get_bytes()) - SVCCTLStartServiceHeader._SVCCTLStartServiceHeader__SIZE
  557.         if not var_size > 0:
  558.             raise AssertionError
  559.         return SVCCTLStartServiceHeader._SVCCTLStartServiceHeader__SIZE + var_size
  560.  
  561.  
  562.  
  563. class SVCCTLRespStartServiceHeader(ImpactPacket.Header):
  564.     __SIZE = 4
  565.     
  566.     def __init__(self, aBuffer = None):
  567.         ImpactPacket.Header.__init__(self, SVCCTLRespStartServiceHeader._SVCCTLRespStartServiceHeader__SIZE)
  568.         if aBuffer:
  569.             self.load_header(aBuffer)
  570.         
  571.  
  572.     
  573.     def get_return_code(self):
  574.         return self.get_long(0, '<')
  575.  
  576.     
  577.     def set_return_code(self, code):
  578.         self.set_long(0, code, '<')
  579.  
  580.     
  581.     def get_header_size(self):
  582.         return SVCCTLRespStartServiceHeader._SVCCTLRespStartServiceHeader__SIZE
  583.  
  584.  
  585.  
  586. class DCERPCSvcCtl:
  587.     
  588.     def __init__(self, dcerpc):
  589.         self._dcerpc = dcerpc
  590.  
  591.     
  592.     def open_manager(self):
  593.         hostname = 'IMPACT'
  594.         opensc = SVCCTLOpenSCManagerHeader()
  595.         opensc.set_machine_name(hostname)
  596.         self._dcerpc.send(opensc)
  597.         data = self._dcerpc.recv()
  598.         retVal = SVCCTLRespOpenSCManagerHeader(data)
  599.         return retVal
  600.  
  601.     
  602.     def create_service(self, context_handle, service_name, service_path):
  603.         creates = SVCCTLCreateServiceHeader()
  604.         creates.set_context_handle(context_handle)
  605.         creates.set_service_name(service_name)
  606.         creates.set_service_path(service_path)
  607.         self._dcerpc.send(creates)
  608.         data = self._dcerpc.recv()
  609.         retVal = SVCCTLRespCreateServiceHeader(data)
  610.         return retVal
  611.  
  612.     
  613.     def close_handle(self, context_handle):
  614.         closeh = SVCCTLCloseServiceHeader()
  615.         closeh.set_context_handle(context_handle)
  616.         self._dcerpc.send(closeh)
  617.         data = self._dcerpc.recv()
  618.         retVal = SVCCTLRespCloseServiceHeader(data)
  619.         return retVal
  620.  
  621.     
  622.     def delete_service(self, context_handle):
  623.         deletes = SVCCTLDeleteServiceHeader()
  624.         deletes.set_context_handle(context_handle)
  625.         self._dcerpc.send(deletes)
  626.         data = self._dcerpc.recv()
  627.         retVal = SVCCTLRespDeleteServiceHeader(data)
  628.         return retVal
  629.  
  630.     
  631.     def open_service(self, context_handle, service_name):
  632.         opens = SVCCTLOpenServiceHeader()
  633.         opens.set_context_handle(context_handle)
  634.         opens.set_service_name(service_name)
  635.         self._dcerpc.send(opens)
  636.         data = self._dcerpc.recv()
  637.         retVal = SVCCTLRespOpenServiceHeader(data)
  638.         return retVal
  639.  
  640.     
  641.     def stop_service(self, context_handle):
  642.         stops = SVCCTLStopServiceHeader()
  643.         stops.set_context_handle(context_handle)
  644.         self._dcerpc.send(stops)
  645.         data = self._dcerpc.recv()
  646.         retVal = SVCCTLRespStopServiceHeader(data)
  647.         return retVal
  648.  
  649.     
  650.     def start_service(self, context_handle, arguments):
  651.         starts = SVCCTLStartServiceHeader()
  652.         starts.set_arguments(arguments)
  653.         starts.set_context_handle(context_handle)
  654.         self._dcerpc.send(starts)
  655.         data = self._dcerpc.recv()
  656.         retVal = SVCCTLRespStartServiceHeader(data)
  657.         return retVal
  658.  
  659.  
  660.